home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / rayshade / libray / libobj / bounds.s < prev    next >
Text File  |  1994-08-01  |  14KB  |  837 lines
  1.     .verstamp    3 18
  2.     .option    pic2
  3.     .rdata    
  4.     .align    2
  5.     .align    0
  6. $$17:
  7.     .ascii    "\X09X: %f to %f\X0A\X00"
  8.     .rdata    
  9.     .align    2
  10.     .align    0
  11. $$18:
  12.     .ascii    "\X09Y: %f to %f\X0A\X00"
  13.     .rdata    
  14.     .align    2
  15.     .align    0
  16. $$19:
  17.     .ascii    "\X09Z: %f to %f\X0A\X00"
  18.     .text    
  19.     .align    2
  20.     .file    2 "bounds.c"
  21.     .globl    BoundsIntersect
  22.     .loc    2 49
  23.  #  49    {
  24.     .ent    BoundsIntersect 2
  25. BoundsIntersect:
  26.     .option    O2
  27.     .set     noreorder
  28.     .cpload    $25
  29.     .set     reorder
  30.     subu    $sp, 16
  31.     s.d    $f20, 8($sp)
  32.     .fmask    0x00300000, -8
  33.     .frame    $sp, 16, $31
  34.     mtc1    $7, $f14
  35.     mtc1    $6, $f15
  36.     lw    $6, 32($sp)
  37.     .loc    2 49
  38.     .loc    2 53
  39.  #  50        Float t, tmin, tmax;
  40.  #  51        Float dir, pos;
  41.  #  52    
  42.  #  53        tmax = *maxdist;
  43.     l.d    $f2, 0($6)
  44.     mov.d    $f0, $f2
  45.     .loc    2 54
  46.  #  54        tmin = mindist;
  47.     mov.d    $f12, $f14
  48.     .loc    2 56
  49.  #  55    
  50.  #  56        dir = ray->dir.x;
  51.     l.d    $f16, 24($4)
  52.     .loc    2 57
  53.  #  57        pos = ray->pos.x;
  54.     l.d    $f18, 0($4)
  55.     .loc    2 59
  56.  #  58    
  57.  #  59        if (dir < 0) {
  58.     li.d    $f4, 0.0000000000000000e+00
  59.     c.lt.d    $f16, $f4
  60.     bc1f    $35
  61.     .loc    2 59
  62.     .loc    2 60
  63.  #  60            t = (bounds[LOW][X] - pos) / dir;
  64.     l.d    $f6, 0($5)
  65.     sub.d    $f8, $f6, $f18
  66.     div.d    $f20, $f8, $f16
  67.     .loc    2 61
  68.  #  61            if (t < tmin)
  69.     c.lt.d    $f20, $f14
  70.     bc1f    $32
  71.     .loc    2 62
  72.  #  62                return FALSE;
  73.     move    $2, $0
  74.     b    $64
  75. $32:
  76.     .loc    2 63
  77.  #  63            if (t <= tmax)
  78.     c.le.d    $f20, $f0
  79.     bc1f    $33
  80.     .loc    2 64
  81.  #  64                tmax = t;
  82.     mov.d    $f0, $f20
  83. $33:
  84.     .loc    2 65
  85.  #  65            t = (bounds[HIGH][X] - pos) / dir;
  86.     l.d    $f10, 24($5)
  87.     sub.d    $f4, $f10, $f18
  88.     div.d    $f20, $f4, $f16
  89.     .loc    2 66
  90.  #  66            if (t >= tmin) {
  91.     c.le.d    $f14, $f20
  92.     bc1f    $41
  93.     .loc    2 66
  94.     .loc    2 67
  95.  #  67                if (t > tmax)
  96.     c.lt.d    $f0, $f20
  97.     bc1f    $34
  98.     .loc    2 68
  99.  #  68                    return FALSE;
  100.     move    $2, $0
  101.     b    $64
  102. $34:
  103.     .loc    2 69
  104.  #  69                tmin = t;
  105.     mov.d    $f12, $f20
  106.     b    $41
  107. $35:
  108.     .loc    2 71
  109.  #  70            }
  110.  #  71        } else if (dir > 0.) {
  111.     li.d    $f6, 0.
  112.     c.lt.d    $f6, $f16
  113.     bc1f    $39
  114.     .loc    2 71
  115.     .loc    2 72
  116.  #  72            t = (bounds[HIGH][X] - pos) / dir;
  117.     l.d    $f8, 24($5)
  118.     sub.d    $f10, $f8, $f18
  119.     div.d    $f20, $f10, $f16
  120.     .loc    2 73
  121.  #  73            if (t < tmin)
  122.     c.lt.d    $f20, $f14
  123.     bc1f    $36
  124.     .loc    2 74
  125.  #  74                return FALSE;
  126.     move    $2, $0
  127.     b    $64
  128. $36:
  129.     .loc    2 75
  130.  #  75            if (t <= tmax)
  131.     c.le.d    $f20, $f0
  132.     bc1f    $37
  133.     .loc    2 76
  134.  #  76                tmax = t;
  135.     mov.d    $f0, $f20
  136. $37:
  137.     .loc    2 77
  138.  #  77            t = (bounds[LOW][X] - pos) / dir;
  139.     l.d    $f4, 0($5)
  140.     sub.d    $f6, $f4, $f18
  141.     div.d    $f20, $f6, $f16
  142.     .loc    2 78
  143.  #  78            if (t >= tmin) {
  144.     c.le.d    $f14, $f20
  145.     bc1f    $41
  146.     .loc    2 78
  147.     .loc    2 79
  148.  #  79                if (t > tmax)
  149.     c.lt.d    $f0, $f20
  150.     bc1f    $38
  151.     .loc    2 80
  152.  #  80                    return FALSE;
  153.     move    $2, $0
  154.     b    $64
  155. $38:
  156.     .loc    2 81
  157.  #  81                tmin = t;
  158.     mov.d    $f12, $f20
  159.     b    $41
  160. $39:
  161.     .loc    2 83
  162.  #  82            }
  163.  #  83        } else if (pos < bounds[LOW][X] || pos > bounds[HIGH][X])
  164.     l.d    $f8, 0($5)
  165.     c.lt.d    $f18, $f8
  166.     bc1t    $40
  167.     l.d    $f10, 24($5)
  168.     c.lt.d    $f10, $f18
  169.     bc1f    $41
  170. $40:
  171.     .loc    2 84
  172.  #  84            return FALSE;
  173.     move    $2, $0
  174.     b    $64
  175. $41:
  176.     .loc    2 86
  177.  #  85    
  178.  #  86        dir = ray->dir.y;
  179.     l.d    $f16, 32($4)
  180.     .loc    2 87
  181.  #  87        pos = ray->pos.y;
  182.     l.d    $f18, 8($4)
  183.     .loc    2 89
  184.  #  88    
  185.  #  89        if (dir < 0) {
  186.     li.d    $f4, 0.0000000000000000e+00
  187.     c.lt.d    $f16, $f4
  188.     bc1f    $45
  189.     .loc    2 89
  190.     .loc    2 90
  191.  #  90            t = (bounds[LOW][Y] - pos) / dir;
  192.     l.d    $f6, 8($5)
  193.     sub.d    $f8, $f6, $f18
  194.     div.d    $f20, $f8, $f16
  195.     .loc    2 91
  196.  #  91            if (t < tmin)
  197.     c.lt.d    $f20, $f12
  198.     bc1f    $42
  199.     .loc    2 92
  200.  #  92                return FALSE;
  201.     move    $2, $0
  202.     b    $64
  203. $42:
  204.     .loc    2 93
  205.  #  93            if (t <= tmax)
  206.     c.le.d    $f20, $f0
  207.     bc1f    $43
  208.     .loc    2 94
  209.  #  94                tmax = t;
  210.     mov.d    $f0, $f20
  211. $43:
  212.     .loc    2 95
  213.  #  95            t = (bounds[HIGH][Y] - pos) / dir;
  214.     l.d    $f10, 32($5)
  215.     sub.d    $f4, $f10, $f18
  216.     div.d    $f20, $f4, $f16
  217.     .loc    2 96
  218.  #  96            if (t >= tmin) {
  219.     c.le.d    $f12, $f20
  220.     bc1f    $51
  221.     .loc    2 96
  222.     .loc    2 97
  223.  #  97                if (t > tmax)
  224.     c.lt.d    $f0, $f20
  225.     bc1f    $44
  226.     .loc    2 98
  227.  #  98                    return FALSE;
  228.     move    $2, $0
  229.     b    $64
  230. $44:
  231.     .loc    2 99
  232.  #  99                tmin = t;
  233.     mov.d    $f12, $f20
  234.     b    $51
  235. $45:
  236.     .loc    2 101
  237.  # 100            }
  238.  # 101        } else if (dir > 0.) {
  239.     li.d    $f6, 0.
  240.     c.lt.d    $f6, $f16
  241.     bc1f    $49
  242.     .loc    2 101
  243.     .loc    2 102
  244.  # 102            t = (bounds[HIGH][Y] - pos) / dir;
  245.     l.d    $f8, 32($5)
  246.     sub.d    $f10, $f8, $f18
  247.     div.d    $f20, $f10, $f16
  248.     .loc    2 103
  249.  # 103            if (t < tmin)
  250.     c.lt.d    $f20, $f12
  251.     bc1f    $46
  252.     .loc    2 104
  253.  # 104                return FALSE;
  254.     move    $2, $0
  255.     b    $64
  256. $46:
  257.     .loc    2 105
  258.  # 105            if (t <= tmax)
  259.     c.le.d    $f20, $f0
  260.     bc1f    $47
  261.     .loc    2 106
  262.  # 106                tmax = t;
  263.     mov.d    $f0, $f20
  264. $47:
  265.     .loc    2 107
  266.  # 107            t = (bounds[LOW][Y] - pos) / dir;
  267.     l.d    $f4, 8($5)
  268.     sub.d    $f6, $f4, $f18
  269.     div.d    $f20, $f6, $f16
  270.     .loc    2 108
  271.  # 108            if (t >= tmin) {
  272.     c.le.d    $f12, $f20
  273.     bc1f    $51
  274.     .loc    2 108
  275.     .loc    2 109
  276.  # 109                if (t > tmax)
  277.     c.lt.d    $f0, $f20
  278.     bc1f    $48
  279.     .loc    2 110
  280.  # 110                    return FALSE;
  281.     move    $2, $0
  282.     b    $64
  283. $48:
  284.     .loc    2 111
  285.  # 111                tmin = t;
  286.     mov.d    $f12, $f20
  287.     b    $51
  288. $49:
  289.     .loc    2 113
  290.  # 112            }
  291.  # 113        } else if (pos < bounds[LOW][Y] || pos > bounds[HIGH][Y])
  292.     l.d    $f8, 8($5)
  293.     c.lt.d    $f18, $f8
  294.     bc1t    $50
  295.     l.d    $f10, 32($5)
  296.     c.lt.d    $f10, $f18
  297.     bc1f    $51
  298. $50:
  299.     .loc    2 114
  300.  # 114            return FALSE;
  301.     move    $2, $0
  302.     b    $64
  303. $51:
  304.     .loc    2 116
  305.  # 115    
  306.  # 116        dir = ray->dir.z;
  307.     l.d    $f16, 40($4)
  308.     .loc    2 117
  309.  # 117        pos = ray->pos.z;
  310.     l.d    $f18, 16($4)
  311.     .loc    2 119
  312.  # 118    
  313.  # 119        if (dir < 0) {
  314.     li.d    $f4, 0.0000000000000000e+00
  315.     c.lt.d    $f16, $f4
  316.     bc1f    $55
  317.     .loc    2 119
  318.     .loc    2 120
  319.  # 120            t = (bounds[LOW][Z] - pos) / dir;
  320.     l.d    $f6, 16($5)
  321.     sub.d    $f8, $f6, $f18
  322.     div.d    $f20, $f8, $f16
  323.     .loc    2 121
  324.  # 121            if (t < tmin)
  325.     c.lt.d    $f20, $f12
  326.     bc1f    $52
  327.     .loc    2 122
  328.  # 122                return FALSE;
  329.     move    $2, $0
  330.     b    $64
  331. $52:
  332.     .loc    2 123
  333.  # 123            if (t <= tmax)
  334.     c.le.d    $f20, $f0
  335.     bc1f    $53
  336.     .loc    2 124
  337.  # 124                tmax = t;
  338.     mov.d    $f0, $f20
  339. $53:
  340.     .loc    2 125
  341.  # 125            t = (bounds[HIGH][Z] - pos) / dir;
  342.     l.d    $f10, 40($5)
  343.     sub.d    $f4, $f10, $f18
  344.     div.d    $f20, $f4, $f16
  345.     .loc    2 126
  346.  # 126            if (t >= tmin) {
  347.     c.le.d    $f12, $f20
  348.     bc1f    $61
  349.     .loc    2 126
  350.     .loc    2 127
  351.  # 127                if (t > tmax)
  352.     c.lt.d    $f0, $f20
  353.     bc1f    $54
  354.     .loc    2 128
  355.  # 128                    return FALSE;
  356.     move    $2, $0
  357.     b    $64
  358. $54:
  359.     .loc    2 129
  360.  # 129                tmin = t;
  361.     mov.d    $f12, $f20
  362.     b    $61
  363. $55:
  364.     .loc    2 131
  365.  # 130            }
  366.  # 131        } else if (dir > 0.) {
  367.     li.d    $f6, 0.
  368.     c.lt.d    $f6, $f16
  369.     bc1f    $59
  370.     .loc    2 131
  371.     .loc    2 132
  372.  # 132            t = (bounds[HIGH][Z] - pos) / dir;
  373.     l.d    $f8, 40($5)
  374.     sub.d    $f10, $f8, $f18
  375.     div.d    $f20, $f10, $f16
  376.     .loc    2 133
  377.  # 133            if (t < tmin)
  378.     c.lt.d    $f20, $f12
  379.     bc1f    $56
  380.     .loc    2 134
  381.  # 134                return FALSE;
  382.     move    $2, $0
  383.     b    $64
  384. $56:
  385.     .loc    2 135
  386.  # 135            if (t <= tmax)
  387.     c.le.d    $f20, $f0
  388.     bc1f    $57
  389.     .loc    2 136
  390.  # 136                tmax = t;
  391.     mov.d    $f0, $f20
  392. $57:
  393.     .loc    2 137
  394.  # 137            t = (bounds[LOW][Z] - pos) / dir;
  395.     l.d    $f4, 16($5)
  396.     sub.d    $f6, $f4, $f18
  397.     div.d    $f20, $f6, $f16
  398.     .loc    2 138
  399.  # 138            if (t >= tmin) {
  400.     c.le.d    $f12, $f20
  401.     bc1f    $61
  402.     .loc    2 138
  403.     .loc    2 139
  404.  # 139                if (t > tmax)
  405.     c.lt.d    $f0, $f20
  406.     bc1f    $58
  407.     .loc    2 140
  408.  # 140                    return FALSE;
  409.     move    $2, $0
  410.     b    $64
  411. $58:
  412.     .loc    2 141
  413.  # 141                tmin = t;
  414.     mov.d    $f12, $f20
  415.     b    $61
  416. $59:
  417.     .loc    2 143
  418.  # 142            }
  419.  # 143        } else if (pos < bounds[LOW][Z] || pos > bounds[HIGH][Z])
  420.     l.d    $f8, 16($5)
  421.     c.lt.d    $f18, $f8
  422.     bc1t    $60
  423.     l.d    $f10, 40($5)
  424.     c.lt.d    $f10, $f18
  425.     bc1f    $61
  426. $60:
  427.     .loc    2 144
  428.  # 144            return FALSE;
  429.     move    $2, $0
  430.     b    $64
  431. $61:
  432.     .loc    2 150
  433.  # 145    
  434.  # 146        /*
  435.  # 147         * If tmin == mindist, then there was no "near"
  436.  # 148         * intersection farther than EPSILON away.
  437.  # 149         */
  438.  # 150        if (tmin == mindist) {
  439.     c.eq.d    $f12, $f14
  440.     bc1f    $62
  441.     .loc    2 150
  442.     .loc    2 151
  443.  # 151            if (tmax < *maxdist) {
  444.     c.lt.d    $f0, $f2
  445.     bc1f    $63
  446.     .loc    2 151
  447.     .loc    2 152
  448.  # 152                *maxdist = tmax;
  449.     s.d    $f0, 0($6)
  450.     .loc    2 153
  451.  # 153                return TRUE;
  452.     li    $2, 1
  453.     b    $64
  454. $62:
  455.     .loc    2 155
  456.  # 154            }
  457.  # 155        } else {
  458.     .loc    2 156
  459.  # 156            if (tmin < *maxdist) {
  460.     c.lt.d    $f12, $f2
  461.     bc1f    $63
  462.     .loc    2 156
  463.     .loc    2 157
  464.  # 157                *maxdist = tmin;
  465.     s.d    $f12, 0($6)
  466.     .loc    2 158
  467.  # 158                return TRUE;
  468.     li    $2, 1
  469.     b    $64
  470. $63:
  471.     .loc    2 161
  472.  # 159            }
  473.  # 160        }
  474.  # 161        return FALSE;    /* hit, but not closer than maxdist */
  475.     move    $2, $0
  476. $64:
  477.     .livereg    0x2000FF0E,0x00000FFF
  478.     l.d    $f20, 8($sp)
  479.     addu    $sp, 16
  480.     j    $31
  481.     .end    BoundsIntersect
  482.     .text    
  483.     .align    2
  484.     .file    2 "bounds.c"
  485.     .globl    BoundsTransform
  486.     .loc    2 172
  487.  # 172    {
  488.     .ent    BoundsTransform 2
  489. BoundsTransform:
  490.     .option    O2
  491.     .set     noreorder
  492.     .cpload    $25
  493.     .set     reorder
  494.     subu    $sp, 152
  495.     sw    $31, 36($sp)
  496.     .cprestore    32
  497.     sw    $17, 28($sp)
  498.     sw    $16, 24($sp)
  499.     .mask    0x90030000, -116
  500.     .frame    $sp, 152, $31
  501.     move    $16, $4
  502.     move    $17, $5
  503.     .loc    2 172
  504.     .loc    2 179
  505.  # 179        if (objbounds[LOW][X] > objbounds[HIGH][X])
  506.     l.d    $f4, 24($17)
  507.     l.d    $f6, 0($17)
  508.     c.lt.d    $f4, $f6
  509.     bc1t    $69
  510.     .loc    2 180
  511.  # 180            return;
  512.     .loc    2 182
  513.  # 181    
  514.  # 182        bounds[LOW][X] = bounds[HIGH][X] = trans->translate.x;
  515.     l.d    $f0, 72($16)
  516.     s.d    $f0, 128($sp)
  517.     s.d    $f0, 104($sp)
  518.     .loc    2 183
  519.  # 183        bounds[LOW][Y] = bounds[HIGH][Y] = trans->translate.y;
  520.     l.d    $f0, 80($16)
  521.     s.d    $f0, 136($sp)
  522.     s.d    $f0, 112($sp)
  523.     .loc    2 184
  524.  # 184        bounds[LOW][Z] = bounds[HIGH][Z] = trans->translate.z;
  525.     l.d    $f0, 88($16)
  526.     s.d    $f0, 144($sp)
  527.     s.d    $f0, 120($sp)
  528.     .loc    2 186
  529.  # 185    
  530.  # 186        for (i = 0; i < 3; i++) {
  531.     move    $3, $0
  532.     move    $7, $0
  533.     addu    $2, $sp, 104
  534.     addu    $9, $sp, 128
  535.     li    $6, 24
  536. $65:
  537.     .loc    2 186
  538.     .loc    2 187
  539.  # 187            for (j = 0; j < 3; j++) {
  540.     move    $8, $0
  541.     move    $4, $0
  542.     move    $3, $17
  543.     addu    $5, $16, $7
  544. $66:
  545.     .loc    2 187
  546.     .loc    2 188
  547.  # 188                a = trans->matrix[j][i] * objbounds[LOW][j];
  548.     l.d    $f0, 0($5)
  549.     l.d    $f8, 0($3)
  550.     mul.d    $f2, $f8, $f0
  551.     .loc    2 189
  552.  # 189                b = trans->matrix[j][i] * objbounds[HIGH][j];
  553.     l.d    $f10, 24($3)
  554.     mul.d    $f12, $f10, $f0
  555.     .loc    2 190
  556.  # 190                if (a < b) {
  557.     c.lt.d    $f2, $f12
  558.     bc1f    $67
  559.     .loc    2 190
  560.     .loc    2 191
  561.  # 191                    bounds[LOW][i] += a;
  562.     .noalias    $2,$gp
  563.     l.d    $f16, 0($2)
  564.     add.d    $f18, $f16, $f2
  565.     s.d    $f18, 0($2)
  566.     .loc    2 192
  567.  # 192                    bounds[HIGH][i] += b;
  568.     l.d    $f4, 24($2)
  569.     add.d    $f6, $f4, $f12
  570.     s.d    $f6, 24($2)
  571.     b    $68
  572. $67:
  573.     .loc    2 193
  574.  # 193                } else {
  575.     .loc    2 194
  576.  # 194                    bounds[LOW][i] += b;
  577.     l.d    $f8, 0($2)
  578.     add.d    $f10, $f8, $f12
  579.     s.d    $f10, 0($2)
  580.     .loc    2 195
  581.  # 195                    bounds[HIGH][i] += a;
  582.     l.d    $f16, 24($2)
  583.     add.d    $f18, $f16, $f2
  584.     s.d    $f18, 24($2)
  585. $68:
  586.     .loc    2 187
  587.  # 187            for (j = 0; j < 3; j++) {
  588.     addu    $4, $4, 8
  589.     addu    $3, $3, 8
  590.     addu    $5, $5, 24
  591.     bne    $4, $6, $66
  592.     .loc    2 186
  593.  # 186        for (i = 0; i < 3; i++) {
  594.     addu    $7, $7, 8
  595.     addu    $2, $2, 8
  596.     bne    $2, $9, $65
  597.     .alias    $2,$gp
  598.     .loc    2 199
  599.  # 199        BoundsCopy(bounds, objbounds);
  600.     addu    $4, $sp, 104
  601.     move    $5, $17
  602.     .livereg    0x0C00000E,0x00000000
  603.     jal    BoundsCopy
  604.     .loc    2 200
  605.  # 200    }
  606. $69:
  607.     .livereg    0x0000FF0E,0x00000FFF
  608.     lw    $16, 24($sp)
  609.     lw    $17, 28($sp)
  610.     lw    $31, 36($sp)
  611.     addu    $sp, 152
  612.     j    $31
  613.     .end    BoundsTransform
  614.     .text    
  615.     .align    2
  616.     .file    2 "bounds.c"
  617.     .globl    BoundsInit
  618.     .loc    2 205
  619.  # 201    
  620.  # 202    void
  621.  # 203    BoundsInit(bounds)
  622.  # 204    Float bounds[2][3];
  623.  # 205    {
  624.     .ent    BoundsInit 2
  625. BoundsInit:
  626.     .option    O2
  627.     .set     noreorder
  628.     .cpload    $25
  629.     .set     reorder
  630.     .frame    $sp, 0, $31
  631.     li.d    $f0, 1.0E+14
  632.     li.d    $f2, -1.0000000000000000e+14
  633.     .loc    2 205
  634.     .loc    2 206
  635.  # 206        bounds[LOW][X] = bounds[LOW][Y] = bounds[LOW][Z] = FAR_AWAY;
  636.     s.d    $f0, 16($4)
  637.     s.d    $f0, 8($4)
  638.     s.d    $f0, 0($4)
  639.     .loc    2 207
  640.  # 207        bounds[HIGH][X] = bounds[HIGH][Y] = bounds[HIGH][Z] = -FAR_AWAY;
  641.     s.d    $f2, 40($4)
  642.     s.d    $f2, 32($4)
  643.     s.d    $f2, 24($4)
  644.     .loc    2 208
  645.  # 208    }
  646.     .livereg    0x0000FF0E,0x00000FFF
  647.     j    $31
  648.     .end    BoundsInit
  649.     .text    
  650.     .align    2
  651.     .file    2 "bounds.c"
  652.     .globl    BoundsCopy
  653.     .loc    2 213
  654.  # 209    
  655.  # 210    void
  656.  # 211    BoundsCopy(from, into)
  657.  # 212    Float into[2][3], from[2][3];
  658.  # 213    {
  659.     .ent    BoundsCopy 2
  660. BoundsCopy:
  661.     .option    O2
  662.     .frame    $sp, 0, $31
  663.     .loc    2 213
  664.     .loc    2 214
  665.  # 214        into[LOW][X] = from[LOW][X];
  666.     l.d    $f4, 0($4)
  667.     s.d    $f4, 0($5)
  668.     .loc    2 215
  669.  # 215        into[LOW][Y] = from[LOW][Y];
  670.     l.d    $f6, 8($4)
  671.     s.d    $f6, 8($5)
  672.     .loc    2 216
  673.  # 216        into[LOW][Z] = from[LOW][Z];
  674.     l.d    $f8, 16($4)
  675.     s.d    $f8, 16($5)
  676.     .loc    2 217
  677.  # 217        into[HIGH][X] = from[HIGH][X];
  678.     l.d    $f10, 24($4)
  679.     s.d    $f10, 24($5)
  680.     .loc    2 218
  681.  # 218        into[HIGH][Y] = from[HIGH][Y];
  682.     l.d    $f16, 32($4)
  683.     s.d    $f16, 32($5)
  684.     .loc    2 219
  685.  # 219        into[HIGH][Z] = from[HIGH][Z];
  686.     l.d    $f18, 40($4)
  687.     s.d    $f18, 40($5)
  688.     .loc    2 220
  689.  # 220    }
  690.     .livereg    0x0000FF0E,0x00000FFF
  691.     j    $31
  692.     .end    BoundsCopy
  693.     .text    
  694.     .align    2
  695.     .file    2 "bounds.c"
  696.     .globl    BoundsEnlarge
  697.     .loc    2 231
  698.  # 231    {
  699.     .ent    BoundsEnlarge 2
  700. BoundsEnlarge:
  701.     .option    O2
  702.     .frame    $sp, 0, $31
  703.     .loc    2 231
  704.     .loc    2 232
  705.  # 232        SetIfLess(old[LOW][X], new[LOW][X]);
  706.     l.d    $f0, 0($4)
  707.     l.d    $f2, 0($5)
  708.     c.lt.d    $f0, $f2
  709.     bc1f    $70
  710.     s.d    $f0, 0($4)
  711.     b    $71
  712. $70:
  713.     s.d    $f2, 0($4)
  714. $71:
  715.     .loc    2 233
  716.  # 233        SetIfLess(old[LOW][Y], new[LOW][Y]);
  717.     l.d    $f0, 8($4)
  718.     l.d    $f2, 8($5)
  719.     c.lt.d    $f0, $f2
  720.     bc1f    $72
  721.     s.d    $f0, 8($4)
  722.     b    $73
  723. $72:
  724.     s.d    $f2, 8($4)
  725. $73:
  726.     .loc    2 234
  727.  # 234        SetIfLess(old[LOW][Z], new[LOW][Z]);
  728.     l.d    $f0, 16($4)
  729.     l.d    $f2, 16($5)
  730.     c.lt.d    $f0, $f2
  731.     bc1f    $74
  732.     s.d    $f0, 16($4)
  733.     b    $75
  734. $74:
  735.     s.d    $f2, 16($4)
  736. $75:
  737.     .loc    2 235
  738.  # 235        SetIfGreater(old[HIGH][X], new[HIGH][X]);
  739.     l.d    $f0, 24($5)
  740.     l.d    $f2, 24($4)
  741.     c.lt.d    $f0, $f2
  742.     bc1f    $76
  743.     s.d    $f2, 24($4)
  744.     b    $77
  745. $76:
  746.     s.d    $f0, 24($4)
  747. $77:
  748.     .loc    2 236
  749.  # 236        SetIfGreater(old[HIGH][Y], new[HIGH][Y]);
  750.     l.d    $f0, 32($5)
  751.     l.d    $f2, 32($4)
  752.     c.lt.d    $f0, $f2
  753.     bc1f    $78
  754.     s.d    $f2, 32($4)
  755.     b    $79
  756. $78:
  757.     s.d    $f0, 32($4)
  758. $79:
  759.     .loc    2 237
  760.  # 237        SetIfGreater(old[HIGH][Z], new[HIGH][Z]);
  761.     l.d    $f0, 40($5)
  762.     l.d    $f2, 40($4)
  763.     c.lt.d    $f0, $f2
  764.     bc1f    $80
  765.     s.d    $f2, 40($4)
  766.     .livereg    0x0000FF0E,0x00000FFF
  767.     j    $31
  768. $80:
  769.     s.d    $f0, 40($4)
  770.     .loc    2 238
  771.  # 238    }
  772. $81:
  773.     .livereg    0x0000FF0E,0x00000FFF
  774.     j    $31
  775.     .end    BoundsEnlarge
  776.     .text    
  777.     .align    2
  778.     .file    2 "bounds.c"
  779.     .globl    BoundsPrint
  780.     .loc    2 244
  781.  # 239    
  782.  # 240    void
  783.  # 241    BoundsPrint(box, fp)
  784.  # 242    Float box[2][3];
  785.  # 243    FILE *fp;
  786.  # 244    {
  787.     .ent    BoundsPrint 2
  788. BoundsPrint:
  789.     .option    O2
  790.     .set     noreorder
  791.     .cpload    $25
  792.     .set     reorder
  793.     subu    $sp, 40
  794.     sw    $31, 36($sp)
  795.     .cprestore    32
  796.     sw    $16, 28($sp)
  797.     .mask    0x90010000, -4
  798.     .frame    $sp, 40, $31
  799.     move    $16, $4
  800.     sw    $5, 44($sp)
  801.     .loc    2 244
  802.     .loc    2 245
  803.  # 245        fprintf(fp,"\tX: %f to %f\n",box[LOW][X], box[HIGH][X]);
  804.     lw    $4, 44($sp)
  805.     la    $5, $$17
  806.     ld    $6, 0($16)
  807.     l.d    $f4, 24($16)
  808.     s.d    $f4, 16($sp)
  809.     .livereg    0x0F00000E,0x00000000
  810.     jal    fprintf
  811.     .loc    2 246
  812.  # 246        fprintf(fp,"\tY: %f to %f\n",box[LOW][Y], box[HIGH][Y]);
  813.     lw    $4, 44($sp)
  814.     la    $5, $$18
  815.     ld    $6, 8($16)
  816.     l.d    $f6, 32($16)
  817.     s.d    $f6, 16($sp)
  818.     .livereg    0x0F00000E,0x00000000
  819.     jal    fprintf
  820.     .loc    2 247
  821.  # 247        fprintf(fp,"\tZ: %f to %f\n",box[LOW][Z], box[HIGH][Z]);
  822.     lw    $4, 44($sp)
  823.     la    $5, $$19
  824.     ld    $6, 16($16)
  825.     l.d    $f8, 40($16)
  826.     s.d    $f8, 16($sp)
  827.     .livereg    0x0F00000E,0x00000000
  828.     jal    fprintf
  829.     .loc    2 248
  830.  # 248    }
  831.     .livereg    0x0000FF0E,0x00000FFF
  832.     lw    $16, 28($sp)
  833.     lw    $31, 36($sp)
  834.     addu    $sp, 40
  835.     j    $31
  836.     .end    BoundsPrint
  837.